// 奇思妙绘首页逻辑
const api = require('../../utils/api');
const util = require('../../utils/util');
const app = getApp();

Page({
  data: {
    prompt: '', // 提示词
    result: '', // 结果图片
    originalImage: '', // 新增：原始图片URL
    generating: false, // 是否正在生成
    showResult: false, // 是否显示结果
    aspectRatio: '1:1', // 默认长宽比(固定为1:1)
    generationProgress: 0, // 生成进度
    taskId: '', // 当前任务ID
    originalMjTaskId: '', // 新增：原始MJ任务ID，用于U和V操作
    showTips: true, // 是否显示提示
    credits: 0, // 积分
    freeCredits: 0, // 免费次数
    hasError: false, // 是否有错误
    errorMsg: '', // 错误信息
    canGenerate: true, // 是否可以生成
    isLoggedIn: false, // 是否已登录
    unfinishedTask: null,
    // 新增图片加载状态
    imageLoading: true,
    imageLoadError: false,
    possibleImageUrls: [],
    currentUrlIndex: 0,
    // 平台内容数据字段
    hotTopics: [],
    recommendedContent: [],
    templates: [],
    loadingPlatformData: false,
    userInfo: null,
    hasRetried: false, // 新增重试标记
    taskCompleted: false, // 新增标志来记录任务是否已完成
    mjTaskId: null, // 新增MJ任务ID字段
    // 新增生成图片列表
    generatedImages: [], // 保存所有生成的图片
    showThumbnails: false, // 是否显示缩略图区域
    currentOperationType: 'original', // 设置当前操作类型为"原始"
    lastGenerationTime: 0, // 新增：最后一次生成图片的时间戳
    cooldownRemaining: 0, // 新增：剩余冷却时间
    cooldownActive: false, // 新增：冷却状态标记
    // 新增翻译相关字段
    translating: false, // 是否正在翻译
    translatedPrompt: '', // 翻译后的英文提示词
    showTranslatedPrompt: false, // 是否显示翻译后的英文提示词
    translationFailed: false, // 翻译是否失败
    // 新增页签相关
    activeTab: 'image', // 默认选中AI生图页签
    inputVisible: true, // 控制底部输入区可见性
    shouldAutoScroll: false, // 新增：控制是否应该自动滚动的标志
    uploadedImages: [], // 用户上传的图片数组
    showScrollHint: false, // 是否显示向下滚动提示
    imageWeight: 1, // 新增：参考图片权重，默认为1
  },

  onLoad: function() {
    console.log('页面加载');
    // 设置默认可以点击生成
    this.setData({
      canGenerate: true,
      activeTab: 'image', // 默认选中AI生图页签
      shouldAutoScroll: false // 默认不允许自动滚动
    });
    
    // 检查登录状态
    this.checkLoginStatusAndInitPage();
    
    // 加载平台内容数据
    this.loadPlatformContent();
  },
  
  onUnload: function() {
    // 清除定时器
    if (this.taskFinishedWatcher) {
      clearInterval(this.taskFinishedWatcher);
    }
    
    // 清除冷却计时器
    if (this.cooldownTimer) {
      clearInterval(this.cooldownTimer);
      this.cooldownTimer = null;
    }
  },
  
  onShow: function() {
    console.log('画图页面显示');
    // 确保页面显示时默认不自动滚动
    this.setData({
      shouldAutoScroll: false
    });
    console.log('页面显示时shouldAutoScroll已重置为:', false);
    
    // 刷新积分和会员状态
    this.refreshCreditsInfo();
    // 更新tabBar选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 0
      });
    }
  },
  
  // 刷新积分信息
  refreshCreditsInfo: function() {
    if (app.globalData.token) {
      // 已登录，获取积分信息
      api.getUserCredits()
        .then(res => {
          if (res && res.data) {
            this.setData({
              credits: res.data.remainCredits || 0,
              freeCredits: app.globalData.userInfo?.freeCredits || 0
            });
          }
        })
        .catch(err => {
          console.error('获取积分信息失败', err);
        });
    }
  },
  
  // 检查登录状态并初始化页面
  checkLoginStatusAndInitPage: function() {
    // 在无需登录模式下，使用匿名用户信息初始化页面
    if (app.globalData.skipLoginMode) {
      console.log('无需登录模式：使用匿名用户信息');
      this.setData({
        isLoggedIn: true,
        userInfo: app.globalData.anonymousUser,
        credits: app.globalData.anonymousUser.credits || 0,
        freeCredits: app.globalData.anonymousUser.freeCredits || 0
      });
      return;
    }
    
    // 正常登录模式
    app.checkLoginStatus()
      .then(isLoggedIn => {
        console.log('登录状态检查结果:', isLoggedIn);
        
        if (isLoggedIn) {
          // 已登录，显示用户信息
          this.setData({
            isLoggedIn: true,
            userInfo: app.globalData.userInfo,
            credits: app.globalData.userInfo.credits || 0,
            freeCredits: app.globalData.userInfo.freeCredits || 0
          });
        } else {
          // 未登录，显示登录按钮
          this.setData({
            isLoggedIn: false,
            userInfo: null
          });
        }
      });
  },
  
  // 加载平台内容数据
  loadPlatformContent: function() {
    // 开始加载
    this.setData({ loadingPlatformData: true });
    
    // 使用Promise.all同时发起多个请求
    Promise.all([
      api.getHotTopics(),
      api.getRecommendContent(),
      api.getPublicTemplates()
    ])
      .then(([topicsRes, contentRes, templatesRes]) => {
        console.log('平台内容加载完成');
        
        // 更新数据
        this.setData({
          hotTopics: topicsRes?.data?.topics || [],
          recommendedContent: contentRes?.data?.content || [],
          templates: templatesRes?.data?.templates || [],
          loadingPlatformData: false
        });
      })
      .catch(err => {
        console.error('加载平台内容失败', err);
        this.setData({ loadingPlatformData: false });
        
        // 静默失败，不影响主功能使用
      });
  },
  
  // 提示词输入处理
  onInputPrompt: function(e) {
    this.setData({
      prompt: e.detail.value
    });
  },
  
  // 清空提示词
  clearPrompt: function() {
    this.setData({
      prompt: ''
    });
  },
  
  // 新增：检查生成冷却时间
  checkCooldown: function() {
    const now = Date.now();
    const cooldownTime = 10000; // 10秒冷却时间（毫秒）
    const lastGen = this.data.lastGenerationTime;
    
    // 如果没有上次生成时间，或者已经过了冷却时间
    if (lastGen === 0 || now - lastGen >= cooldownTime) {
      this.setData({
        cooldownActive: false,
        cooldownRemaining: 0
      });
      return true; // 可以生成
    }
    
    // 计算剩余冷却时间
    const remaining = Math.ceil((cooldownTime - (now - lastGen)) / 1000);
    
    this.setData({
      cooldownActive: true,
      cooldownRemaining: remaining
    });
    
    // 显示提示
    tt.showToast({
      title: `请等待${remaining}秒后再试`,
      icon: 'none',
      duration: 2000
    });
    
    // 启动倒计时更新
    this.startCooldownTimer();
    
    return false; // 不能生成
  },
  
  // 新增：启动冷却倒计时
  startCooldownTimer: function() {
    // 清除已有的计时器
    if (this.cooldownTimer) {
      clearInterval(this.cooldownTimer);
    }
    
    // 设置新的计时器，每秒更新一次
    this.cooldownTimer = setInterval(() => {
      const now = Date.now();
      const cooldownTime = 10000; // 10秒
      const lastGen = this.data.lastGenerationTime;
      const remaining = Math.ceil((cooldownTime - (now - lastGen)) / 1000);
      
      if (remaining <= 0) {
        // 冷却结束
        this.setData({
          cooldownActive: false,
          cooldownRemaining: 0
        });
        
        // 清除计时器
        clearInterval(this.cooldownTimer);
        this.cooldownTimer = null;
        
        // 可选：通知用户冷却结束
        tt.showToast({
          title: '可以继续生成图片了',
          icon: 'none',
          duration: 1500
        });
      } else {
        // 更新剩余时间
        this.setData({
          cooldownRemaining: remaining
        });
      }
    }, 1000);
  },
  
  // 开始生成图片
  generateImage: function() {
    // 如果正在生成或者没有提示词，直接返回
    if (this.data.generating || !this.data.prompt) {
      return;
    }
    
    // 如果在冷却中，也直接返回
    if (this.data.cooldownActive) {
      wx.showToast({
        title: `请等待${this.data.cooldownRemaining}秒后再试`,
        icon: 'none'
      });
      return;
    }
    
    // 记录上传的图片信息（这里可以添加图片上传到服务器的逻辑）
    const hasReferenceImages = this.data.uploadedImages.length > 0;
    
    // 设置生成状态
    this.setData({
      generating: true,
      translating: true, // 设置为正在翻译状态
      translationFailed: false, // 重置翻译失败状态
      generationProgress: 3, // 从3%开始，表示翻译阶段
      errorMsg: '',
      hasRetried: false, // 重置重试标记
      result: '', // 清除上一次的结果
      originalImage: '', // 清除原始图片
      imageLoadError: false,
      taskCompleted: false, // 重置任务完成标志
      mjTaskId: null, // 重置MJ任务ID
      originalMjTaskId: '', // 重置原始MJ任务ID
      generatedImages: [], // 重置生成图片列表
      showThumbnails: false, // 隐藏缩略图区域
      currentOperationType: 'original', // 设置当前操作类型为"原始"
      lastGenerationTime: Date.now(), // 记录当前生成时间
      translatedPrompt: '', // 清空翻译结果
      showTranslatedPrompt: false, // 隐藏翻译提示词显示
      shouldAutoScroll: false // 原始图片生成不需要自动滚动
    });
    
    console.log('开始翻译提示词:', this.data.prompt);
    
    // 显示加载提示
    tt.showLoading({
      title: '正在翻译提示词...',
      mask: true
    });
    
    // 首先处理上传的参考图片（如果有）
    let imageProcessPromise = Promise.resolve([]);
    if (hasReferenceImages) {
      console.log('检测到上传的参考图片，开始转换为base64...');
      imageProcessPromise = this.convertImagesToBase64(this.data.uploadedImages);
    }

    // 处理参考图片和翻译提示词
    Promise.all([
      imageProcessPromise,
      api.translatePromptWithDeepSeek(this.data.prompt)
    ])
      .then(([base64Images, translationRes]) => {
        console.log('提示词翻译成功:', translationRes);
        console.log(`参考图片处理完成: ${base64Images.length}张`);
        
        if (translationRes.success && translationRes.translatedPrompt) {
          // 更新进度，表示翻译完成，并保存翻译结果
          this.setData({
            generationProgress: 5,
            translating: false, // 翻译完成
            translatedPrompt: translationRes.translatedPrompt,
            showTranslatedPrompt: true // 显示翻译结果
          });
          
          tt.showLoading({
            title: '正在创作中...',
            mask: true
          });
          
          const translatedPrompt = translationRes.translatedPrompt;
          console.log('开始使用翻译后的提示词生成图片:', translatedPrompt);
          
          // 构建生成参数，添加base64Array
          const options = {
            width: 512,
            height: 512,
            style: '写实',
            originalPrompt: this.data.prompt // 传递原始提示词，可用于服务端记录
          };
          
          // 如果有参考图片，则添加到options中
          if (base64Images.length > 0) {
            console.log('添加参考图片到生成参数');
            options.base64Array = base64Images; // 添加转换后的base64图片数组
            options.imageWeight = this.data.imageWeight; // 添加参考图片权重参数
            console.log(`图片权重设置为：${this.data.imageWeight}`);
          }
          
          // 使用翻译后的英文提示词调用画图API
          return api.createDrawing(translatedPrompt, options);
        } else {
          // 翻译失败，尝试使用原始提示词
          console.warn('翻译失败，尝试使用原始中文提示词');
          
          this.setData({
            translating: false,
            translationFailed: true, // 标记翻译失败
            generationProgress: 5
          });
          
          tt.showToast({
            title: '翻译失败，使用原始提示词',
            icon: 'none',
            duration: 2000
          });
          
          tt.showLoading({
            title: '正在创作中...',
            mask: true
          });
          
          // 构建生成参数
          const options = {
            width: 512,
            height: 512,
            style: '写实'
          };
          
          // 如果有参考图片，则添加到options中
          if (base64Images.length > 0) {
            console.log('添加参考图片到生成参数');
            options.base64Array = base64Images; // 添加转换后的base64图片数组
            options.imageWeight = this.data.imageWeight; // 添加参考图片权重参数
            console.log(`图片权重设置为：${this.data.imageWeight}`);
          }
          
          return api.createDrawing(this.data.prompt, options);
        }
      })
      .then(res => {
        console.log('创建画图任务成功:', res);
        
        if (res.code === 0 && res.data) {
          // 检查是否直接返回了MJ任务ID
          if (res.data.mjTaskId) {
            console.log('服务器直接返回了MJ任务ID:', res.data.mjTaskId);
            // 保存MJ任务ID到页面数据和本地存储
            this.setData({
              mjTaskId: res.data.mjTaskId,
              originalMjTaskId: res.data.mjTaskId // 同时保存为原始任务ID
            });
            
            try {
              tt.setStorageSync('mjTaskId', res.data.mjTaskId);
              tt.setStorageSync('originalMjTaskId', res.data.mjTaskId); // 保存原始任务ID
              console.log('已将原始MJ任务ID保存到本地存储:', res.data.mjTaskId);
            } catch (e) {
              console.error('保存MJ任务ID到本地存储失败:', e);
            }
          }
          
          if (res.data.taskId) {
            // 有任务ID，开始轮询结果
            // 添加任务完成状态检查，避免已完成任务继续查询
            if (!this.data.taskCompleted) {
              this.queryDrawingResult(res.data.taskId);
            } else {
              console.log('任务已完成，不需要开始查询');
              tt.hideLoading();
            }
          } else {
            throw new Error(res.message || '创建画图任务失败：未返回任务ID');
          }
        } else {
          throw new Error(res.message || '创建画图任务失败');
        }
      })
      .catch(err => {
        console.error('处理失败:', err);
        
        tt.hideLoading();
        this.setData({
          generating: false,
          translating: false,
          taskCompleted: true, // 标记任务完成，即使是失败的情况
          errorMsg: err.message || '创建画图任务失败，请重试'
        });
        
        tt.showToast({
          title: '处理失败',
          icon: 'none'
        });
      });
  },
  
  // 查询画图结果
  queryDrawingResult: function(taskId) {
    console.log('查询画图结果，任务ID:', taskId);
    
    // 如果任务已完成，不再继续查询
    if (this.data.taskCompleted) {
      console.log('任务已完成，不再继续查询结果');
      return;
    }
    
    // 先保存系统任务ID，即使可能需要后续更新为MJ任务ID
    // 这样做可以确保至少有一个任务ID可用
    if (taskId && taskId !== this.data.taskId) {
      console.log('保存系统任务ID到页面数据:', taskId);
      this.setData({
        taskId: taskId
      });
    }
    
    api.queryDrawingResult(taskId)
      .then(res => {
        console.log('查询画图结果完整响应:', JSON.stringify(res));
        
        if (res.code === 0 && res.data) {
          const status = res.data.status;
          console.log(`任务${taskId}状态:`, status);
          
          // 尝试获取实际的Midjourney任务ID，更全面的提取
          let mjTaskId = null;
          
          // 优先检查服务器可能直接返回的mjTaskId字段
          if (res.data.mjTaskId) {
            mjTaskId = res.data.mjTaskId;
            console.log('从服务器响应中直接获取MJ任务ID:', mjTaskId);
          }
          // 其次检查API响应中的特定字段，提取真正的MJ任务ID
          else if (res.data.result && res.data.result.mjTaskId) {
            // 从result.mjTaskId字段获取
            mjTaskId = res.data.result.mjTaskId;
            console.log('从result.mjTaskId中提取到MJ任务ID:', mjTaskId);
          } else if (res.data.mjTaskId) {
            // 直接从响应的mjTaskId字段获取
            mjTaskId = res.data.mjTaskId;
            console.log('从mjTaskId字段中提取到MJ任务ID:', mjTaskId);
          } else if (res.data.result && res.data.result.taskIdMapping && res.data.result.taskIdMapping.mjId) {
            // 从taskIdMapping.mjId字段获取
            mjTaskId = res.data.result.taskIdMapping.mjId;
            console.log('从taskIdMapping.mjId字段中提取到MJ任务ID:', mjTaskId);
          } else if (res.data.result && res.data.result.discordTaskId) {
            // 从discordTaskId字段获取
            mjTaskId = res.data.result.discordTaskId;
            console.log('从discordTaskId字段中提取到MJ任务ID:', mjTaskId);
          }
          
          // 查找特定格式的MJ任务ID(纯数字15-25位)
          if (!mjTaskId) {
            const jsonStr = JSON.stringify(res.data);
            const idMatch = jsonStr.match(/"(?:mjTaskId|discordTaskId|taskId|id)"\s*:\s*"?(\d{15,25})"?/);
            if (idMatch && idMatch[1]) {
              mjTaskId = idMatch[1];
              console.log('从JSON中正则匹配提取到MJ任务ID:', mjTaskId);
            }
          }
          
          // 如果仍找不到，从日志响应中搜索
          if (!mjTaskId && res.data.log) {
            // 正则搜索日志中的"MJ任务ID: 数字"格式
            const logMatch = res.data.log.match(/MJ[^:]*ID:\s*(\d{15,25})/i);
            if (logMatch && logMatch[1]) {
              mjTaskId = logMatch[1];
              console.log('从日志中提取到MJ任务ID:', mjTaskId);
            }
          }
          
          // 验证提取到的MJ任务ID格式是否正确(通常是15-25位数字)
          if (mjTaskId && /^\d{15,25}$/.test(mjTaskId)) {
            console.log('验证通过：提取到的MJ任务ID格式正确:', mjTaskId);
          } else if (mjTaskId) {
            console.warn('警告：提取到的MJ任务ID可能格式不正确:', mjTaskId);
          }
          
          // 保存MJ任务ID到页面数据，以便后续放大和变体操作使用
          if (mjTaskId) {
            console.log('保存真正的MJ任务ID到页面数据:', mjTaskId);
            this.setData({
              mjTaskId: mjTaskId // 专门存储MJ任务ID
            });
            
            // 保存MJ任务ID到本地存储，以便应用重启后仍能使用
            try {
              tt.setStorageSync('mjTaskId', mjTaskId);
              console.log('已将MJ任务ID保存到本地存储:', mjTaskId);
              
              // 检查是否需要保存为原始任务ID（仅在首次生成时）
              if (!this.data.originalMjTaskId) {
                console.log('首次生成图片，保存MJ任务ID为原始任务ID:', mjTaskId);
                this.setData({
                  originalMjTaskId: mjTaskId
                });
                tt.setStorageSync('originalMjTaskId', mjTaskId);
              }
            } catch (e) {
              console.error('保存MJ任务ID到本地存储失败:', e);
            }
          }
          
          if (status === 'completed') {
            // 生成完成
            tt.hideLoading();
            console.log('生成完成，原始返回的图片URL:', res.data.imageUrl);
            
            // 直接使用服务器返回的imageUrl
            // 不再尝试提取或构造其他URL
            if (res.data.imageUrl) {
              // 处理相对路径问题，将相对路径转换为完整URL
              let finalImageUrl = res.data.imageUrl;
              if (finalImageUrl.startsWith('/')) {
                finalImageUrl = `${app.globalData.apiBaseUrl}${finalImageUrl}`;
                console.log('将相对路径转换为完整URL:', finalImageUrl);
              }
              
              console.log('使用处理后的imageUrl:', finalImageUrl);
              
              // 创建新图片对象
              const newImage = {
                id: `img_${Date.now()}`,
                url: finalImageUrl,
                taskId: taskId,
                mjTaskId: mjTaskId || this.data.mjTaskId,
                timestamp: Date.now(),
                type: this.data.currentOperationType || 'original', // 记录操作类型：原始、放大或变体
                isActive: true // 标记默认为激活状态
              };
              
              // 获取当前图片列表
              let updatedImages = [...this.data.generatedImages];
              
              // 判断当前操作类型，处理不同的逻辑
              if (this.data.currentOperationType === 'original') {
                // 如果是原始图片，保存到originalImage
                this.setData({
                  originalImage: finalImageUrl
                });
                console.log('保存原始图片URL:', finalImageUrl);
              } else if (this.data.currentOperationType === 'upscale' || this.data.currentOperationType === 'variation') {
                // 如果是放大或变体操作，添加到衍生图片列表
                // 先将所有现有图片标记为非激活状态
                updatedImages = updatedImages.map(img => ({
                  ...img,
                  isActive: false
                }));
                // 然后添加新图片（已标记为激活状态）
                updatedImages.push(newImage);
              }
              
              this.setData({
                generating: false,
                showResult: false,
                result: this.data.currentOperationType === 'original' ? finalImageUrl : this.data.originalImage, // 根据操作类型决定显示哪张图片
                possibleImageUrls: [finalImageUrl], // 只保留处理后的URL
                currentUrlIndex: 0,
                generationProgress: 100,
                taskCompleted: true, // 标记任务已完成
                // 更新剩余积分（如果返回）
                credits: res.data.remainCredits || this.data.credits,
                freeCredits: res.data.freeCredits || this.data.freeCredits,
                // 更新图片列表
                generatedImages: updatedImages,
                showThumbnails: updatedImages.length > 0 // 仅当有衍生图片时才显示缩略图区域
              }, () => {
                console.log('数据更新完成回调执行');
                // 数据更新完成后，仅在原始图片生成完成或衍生图片生成完成时才滚动
                if (this.data.currentOperationType === 'original') {
                  console.log('原始图片生成完成，滚动到图片区域');
                  setTimeout(() => {
                    this.scrollToView('.result-image');
                  }, 300);
                } else if (this.data.currentOperationType === 'upscale' || this.data.currentOperationType === 'variation') {
                  console.log('衍生图片生成完成，滚动到缩略图区域');
                  setTimeout(() => {
                    this.scrollToView('.thumbnails-container');
                  }, 500);
                }
              });
              
              // 更新匿名用户信息
              if (app.globalData.skipLoginMode && res.data.remainCredits) {
                app.globalData.anonymousUser.credits = res.data.remainCredits;
                app.globalData.anonymousUser.freeCredits = res.data.freeCredits || 0;
              }
              
              tt.showToast({
                title: '创作完成',
                icon: 'success'
              });
            } else {
              // 如果没有imageUrl，显示错误
              this.setData({
                generating: false,
                taskCompleted: true, // 标记任务已完成，即使是失败的情况
                hasError: true,
                errorMsg: '服务器未返回图片URL'
              });
              
              tt.showToast({
                title: '生成失败',
                icon: 'none'
              });
            }
          } else if (status === 'failed') {
            // 生成失败
            tt.hideLoading();
            
            this.setData({
              generating: false,
              taskCompleted: true, // 标记任务已完成，即使是失败的情况
              hasError: true,
              errorMsg: res.data.errorMessage || '生成图片失败，请重试'
            });
            
            tt.showToast({
              title: '生成失败',
              icon: 'none'
            });
          } else {
            // 仍在处理中，继续轮询
            // 更新进度（如果有）
            if (res.data.progress) {
              let progress = parseInt(res.data.progress);
              if (!isNaN(progress)) {
                // 确保进度在5-95之间，避免显示0或100
                progress = Math.max(5, Math.min(progress, 95));
                this.setData({
                  generationProgress: progress
                });
              }
            }
            
            // 只有在任务未完成的情况下继续轮询
            if (!this.data.taskCompleted) {
              setTimeout(() => {
                this.queryDrawingResult(taskId);
              }, 2000); // 每2秒查询一次
            }
          }
        } else {
          throw new Error(res.message || '查询画图结果失败');
        }
      })
      .catch(err => {
        console.error('查询画图结果失败:', err);
        
        tt.hideLoading();
        this.setData({
          generating: false,
          errorMsg: err.message || '查询画图结果失败，请重试'
        });
        
        tt.showToast({
          title: '查询结果失败',
          icon: 'none'
        });
      });
  },
  
  // 从URL中提取任务ID
  extractTaskIdFromUrl: function(url) {
    if (!url) return null;
    
    // 尝试从cdn.midjourney.com格式的URL中提取ID
    // 格式可能是：https://cdn.midjourney.com/[id]/0_0.png
    const regex = /cdn\.midjourney\.com\/([^\/]+)/;
    const match = url.match(regex);
    
    if (match && match[1]) {
      return match[1];
    }
    
    return null;
  },
  
  // 从响应中提取Discord URL
  extractDiscordUrlFromResponse: function(data) {
    console.log('尝试从响应数据中提取Discord URL...');
    
    // 检查直接的imageUrl字段 (最常见情况)
    if (data.imageUrl && data.imageUrl.includes('cdn.discordapp.com')) {
      console.log('在imageUrl字段中发现Discord URL');
      return data.imageUrl;
    }
    
    // 检查各种可能的字段名
    if (data.discordUrl) return data.discordUrl;
    if (data.discordImageUrl) return data.discordImageUrl;
    
    // 检查是否有raw字段包含JSON响应
    if (data.raw) {
      try {
        let rawObj = data.raw;
        if (typeof rawObj === 'string') {
          rawObj = JSON.parse(rawObj);
        }
        
        if (rawObj.imageUrl && rawObj.imageUrl.includes('cdn.discordapp.com')) {
          console.log('在raw.imageUrl中发现Discord URL');
          return rawObj.imageUrl;
        }
      } catch (e) {
        console.error('解析raw字段失败:', e);
      }
    }
    
    // 从日志中提取完整URL
    // 格式可能是: "图片URL: https://cdn.discordapp.com/attachments/..."
    if (typeof data.log === 'string' && data.log.includes('图片URL:')) {
      const match = data.log.match(/图片URL:\s+(https:\/\/cdn\.discordapp\.com\/attachments\/[^\s&"]+)/);
      if (match && match[1]) {
        console.log('从日志中提取到Discord URL:', match[1]);
        return match[1];
      }
    }
    
    // 检查responseText或responseJson字段
    if (data.responseText && typeof data.responseText === 'string') {
      try {
        // 尝试用正则提取URL，避免解析可能有问题的JSON
        const urlMatch = data.responseText.match(/"imageUrl"\s*:\s*"(https:\/\/cdn\.discordapp\.com\/attachments\/[^"]+)"/);
        if (urlMatch && urlMatch[1]) {
          console.log('从responseText中提取到Discord URL:', urlMatch[1]);
          return urlMatch[1];
        }
      } catch (e) {
        console.error('解析responseText失败:', e);
      }
    }
    
    // 检查result对象中是否有Discord URL
    if (data.result) {
      if (typeof data.result === 'object') {
        // 检查result对象中的字段
        if (data.result.discordUrl) return data.result.discordUrl;
        if (data.result.discordImageUrl) return data.result.discordImageUrl;
        if (data.result.imageUrl && data.result.imageUrl.includes('cdn.discordapp.com')) {
          console.log('在result.imageUrl中发现Discord URL');
          return data.result.imageUrl;
        }
        
        // 检查result.log字段
        if (typeof data.result.log === 'string' && data.result.log.includes('图片URL:')) {
          const match = data.result.log.match(/图片URL:\s+(https:\/\/cdn\.discordapp\.com\/attachments\/[^\s&"]+)/);
          if (match && match[1]) {
            console.log('从result.log中提取到Discord URL:', match[1]);
            return match[1];
          }
        }
      } else if (typeof data.result === 'string') {
        // 检查result字符串是否直接是URL或包含URL
        if (data.result.includes('cdn.discordapp.com')) {
          // 尝试提取完整URL
          const urlMatch = data.result.match(/(https:\/\/cdn\.discordapp.com\/attachments\/[^\s"&]+)/);
          if (urlMatch && urlMatch[1]) {
            console.log('从result字符串中提取到Discord URL:', urlMatch[1]);
            return urlMatch[1];
          }
        }
        
        // 尝试解析result字符串为JSON
        try {
          const resultObj = JSON.parse(data.result);
          if (resultObj.imageUrl && resultObj.imageUrl.includes('cdn.discordapp.com')) {
            console.log('从解析的result JSON中提取到Discord URL');
            return resultObj.imageUrl;
          }
        } catch (e) {
          // 解析失败，忽略错误
        }
      }
    }
    
    // 检查是否有mjTaskId或imageUrl中的ID可以从响应中提取
    let mjTaskId = null;
    
    // 从直接提供的任务ID字段检查
    if (data.id) mjTaskId = data.id;
    if (data.mjTaskId) mjTaskId = data.mjTaskId;
    if (data.taskId && !isNaN(data.taskId) && data.taskId.toString().length > 10) {
      mjTaskId = data.taskId;
    }
    
    // 从imageUrl中提取任务ID
    if (!mjTaskId && data.imageUrl && data.imageUrl.includes('cdn.midjourney.com')) {
      mjTaskId = this.extractTaskIdFromUrl(data.imageUrl);
    }
    
    // 从JSON字符串中尝试提取任务ID
    if (!mjTaskId) {
      // 尝试解析整个响应对象为字符串并查找ID
      try {
        const jsonStr = JSON.stringify(data);
        // 查找类似"id":"1743678325038415"的模式
        const idMatch = jsonStr.match(/"id"\s*:\s*"?(\d{15,20})"?/);
        if (idMatch && idMatch[1]) {
          console.log('从JSON字符串中提取到任务ID:', idMatch[1]);
          mjTaskId = idMatch[1];
        }
      } catch (e) {
        console.error('将响应对象序列化为JSON失败:', e);
      }
    }
    
    // 从imageUrl中检查是否包含Discord CDN链接
    if (data.imageUrl && data.imageUrl.includes('cdn.discordapp.com')) {
      return data.imageUrl;
    }
    
    // 尝试从任何其他可能包含Discord URL的字段中查找
    for (const key in data) {
      // 检查字符串字段中是否有完整Discord URL
      if (typeof data[key] === 'string') {
        // 直接检查是否包含完整的Discord URL
        if (data[key].includes('cdn.discordapp.com') && data[key].includes('attachments')) {
          return data[key];
        }
        
        // 检查是否包含格式为"URL: https://..."的字符串
        if (data[key].includes('URL:') || data[key].includes('图片URL:')) {
          const match = data[key].match(/(图片)?URL:\s+(https:\/\/cdn\.discordapp\.com\/attachments\/[^\s&"]+)/);
          if (match && match[2]) {
            console.log(`从${key}字段中提取到Discord URL:`, match[2]);
            return match[2];
          }
        }
      }
      
      // 递归检查对象字段
      if (typeof data[key] === 'object' && data[key] !== null && key !== 'possibleImageUrls') {
        try {
          const nestedUrl = this.findDiscordUrlInObject(data[key]);
          if (nestedUrl) {
            return nestedUrl;
          }
        } catch (e) {
          console.error(`处理${key}字段时出错:`, e);
        }
      }
    }
    
    // 当没有找到时返回null
    return null;
  },
  
  // 递归查找对象中的Discord URL
  findDiscordUrlInObject: function(obj, depth = 0) {
    // 防止过深递归
    if (depth > 3) return null;
    
    // 防止错误
    if (!obj || typeof obj !== 'object') return null;
    
    for (const key in obj) {
      // 检查字符串值是否包含Discord URL
      if (typeof obj[key] === 'string') {
        // 直接的URL
        if (obj[key].includes('cdn.discordapp.com') && obj[key].includes('attachments')) {
          return obj[key];
        }
        
        // "URL: https://..."格式
        if (obj[key].includes('URL:') || obj[key].includes('图片URL:')) {
          const match = obj[key].match(/(图片)?URL:\s+(https:\/\/cdn\.discordapp\.com\/attachments\/[^\s&"]+)/);
          if (match && match[2]) {
            return match[2];
          }
        }
        
        // 检查是否是包含URL的JSON字符串
        if (obj[key].includes('"imageUrl"') && obj[key].includes('cdn.discordapp.com')) {
          try {
            // 尝试用正则提取URL，避免解析可能有问题的JSON
            const urlMatch = obj[key].match(/"imageUrl"\s*:\s*"(https:\/\/cdn\.discordapp\.com\/attachments\/[^"]+)"/);
            if (urlMatch && urlMatch[1]) {
              console.log('从JSON字符串中提取到Discord URL:', urlMatch[1]);
              return urlMatch[1];
            }
          } catch (e) {
            console.error('解析JSON字符串失败:', e);
          }
        }
      }
      
      // 递归检查嵌套对象
      if (typeof obj[key] === 'object' && obj[key] !== null) {
        const nestedUrl = this.findDiscordUrlInObject(obj[key], depth + 1);
        if (nestedUrl) {
          return nestedUrl;
        }
      }
    }
    
    return null;
  },
  
  // 预览图片 - 使用自定义预览而非系统预览
  previewImage: function() {
    if (!this.data.result) return;
    
    // 使用自己的结果显示区域而不是系统预览
    this.setData({
      showResult: true
    });
    
    /* 注释掉系统预览，避免需要长按保存
    tt.previewImage({
      urls: [this.data.result],
      current: this.data.result
    });
    */
  },
  
  // 重试加载图片
  retryLoadImage: function() {
    this.setData({
      imageLoading: true,
      imageLoadError: false
    });
    
    // 尝试重新加载当前URL
    const currentUrl = this.data.result;
    
    // 添加随机参数避免缓存
    const timestamp = new Date().getTime();
    const refreshedUrl = currentUrl.includes('?') 
      ? `${currentUrl}&t=${timestamp}` 
      : `${currentUrl}?t=${timestamp}`;
    
    console.log('重试加载图片:', refreshedUrl);
    
    this.setData({
      result: refreshedUrl
    });
  },
  
  // 尝试使用其他图片源
  tryAlternateSource: function() {
    if (!this.data.possibleImageUrls || this.data.possibleImageUrls.length <= 1) {
      return;
    }
    
    // 计算下一个索引（循环）
    const nextIndex = (this.data.currentUrlIndex + 1) % this.data.possibleImageUrls.length;
    const nextUrl = this.data.possibleImageUrls[nextIndex];
    
    console.log(`切换到下一个图片源 (${nextIndex}/${this.data.possibleImageUrls.length-1}): ${nextUrl}`);
    
    this.setData({
      result: nextUrl,
      currentUrlIndex: nextIndex,
      imageLoading: true,
      imageLoadError: false
    });
    
    tt.showToast({
      title: '正在尝试其他图片源',
      icon: 'none'
    });
  },
  
  // 图片加载完成
  handleImageLoad: function() {
    console.log('图片加载成功:', this.data.originalImage);
    console.log('当前操作类型:', this.data.currentOperationType);
    
    // 图片加载成功，标记任务完成，不再继续查询
    this.setData({
      imageLoading: false,
      imageLoadError: false,
      taskCompleted: true, // 标记任务已完成
      showScrollHint: true // 显示向下滚动提示
    });
    
    console.log('图片加载完成，任务已标记为完成状态');
    
    // 不再执行额外的滚动操作，已经在任务完成时处理过滚动了

    // 10秒后自动隐藏箭头提示
    setTimeout(() => {
      this.setData({
        showScrollHint: false
      });
    }, 10000);
  },
  
  // 处理图片加载错误
  handleImageError: function(e) {
    console.error('图片加载错误:', e);
    
    // 设置加载错误状态
    this.setData({
      imageLoading: false,
      imageLoadError: true
    });
    
    // 记录当前URL
    const currentUrl = this.data.originalImage;
    console.error(`图片URL加载失败: ${currentUrl}`);
    
    // 如果需要重试，可以添加时间戳避免缓存
    if (!this.data.hasRetried) {
      console.log('添加时间戳重试原始URL');
      
      // 添加随机参数避免缓存
      const timestamp = new Date().getTime();
      const refreshedUrl = currentUrl.includes('?') 
        ? `${currentUrl}&t=${timestamp}` 
        : `${currentUrl}?t=${timestamp}`;
      
      this.setData({
        originalImage: refreshedUrl,
        imageLoading: true,
        imageLoadError: false,
        hasRetried: true // 标记已经重试过
      });
      
      tt.showToast({
        title: '正在重试加载图片',
        icon: 'none',
        duration: 1500
      });
    } else {
      // 已经重试过，提示加载失败
      console.error('图片加载失败，已重试');
      
      tt.showToast({
        title: '图片加载失败',
        icon: 'none'
      });
    }
  },
  
  // 从任何可能的源中提取Midjourney任务ID
  extractMidJourneyTaskIdFromAnySource: function() {
    console.log('尝试从任何可能的源中提取Midjourney任务ID');
    
    // 输出当前的重要信息，帮助调试
    console.log('当前系统任务ID:', this.data.taskId);
    console.log('当前MJ任务ID:', this.data.mjTaskId);
    console.log('当前图片URL:', this.data.result);
    console.log('当前可能的图片URL列表:', this.data.possibleImageUrls);
    
    // 首先检查是否有专用的MJ任务ID字段
    if (this.data.mjTaskId) {
      // 验证格式是否正确（纯数字15-25位）
      if(/^\d{15,25}$/.test(this.data.mjTaskId)) {
        console.log('从页面data.mjTaskId中获取到标准格式的MJ任务ID:', this.data.mjTaskId);
        return this.data.mjTaskId;
      } else {
        console.warn('页面data.mjTaskId值存在但格式不标准:', this.data.mjTaskId);
      }
    }
    
    // 从本地存储中尝试获取
    try {
      const storedMjTaskId = tt.getStorageSync('mjTaskId');
      if (storedMjTaskId && /^\d{15,25}$/.test(storedMjTaskId)) {
        console.log('从本地存储中找到有效的MJ任务ID:', storedMjTaskId);
        return storedMjTaskId;
      } else if (storedMjTaskId) {
        console.warn('本地存储中的MJ任务ID格式不标准:', storedMjTaskId);
      }
    } catch (e) {
      console.error('读取本地存储失败:', e);
    }
    
    // 检查是否有可能存储在taskId中的MJ任务ID（纯数字格式）
    if (this.data.taskId && /^\d{15,25}$/.test(this.data.taskId)) {
      console.log('从页面data.taskId中获取到合法格式的MJ任务ID:', this.data.taskId);
      return this.data.taskId;
    }
    
    // 从当前URL中提取
    if (this.data.result) {
      // 检查是否是Discord URL
      if (this.data.result.includes('cdn.discordapp.com')) {
        // 尝试从Discord URL路径中提取文件名部分
        const match = this.data.result.match(/\/funtansea_\d+_[^\/]+_([a-f0-9-]+)\.png/);
        if (match && match[1]) {
          console.log('从Discord URL中提取到任务ID特征:', match[1]);
          // 这不是实际的任务ID，但可以用于调试
        }
        
        // 尝试从URL中的数字部分推断任务ID
        const numericMatch = this.data.result.match(/\/(\d{15,25})\//);
        if (numericMatch && numericMatch[1]) {
          console.log('从Discord URL中提取到可能的MJ任务ID:', numericMatch[1]);
          return numericMatch[1];
        }
      }
      
      // 检查是否是Midjourney URL
      if (this.data.result.includes('midjourney.com')) {
        const mjTaskId = this.extractTaskIdFromUrl(this.data.result);
        if (mjTaskId) {
          console.log('从Midjourney URL中提取到任务ID:', mjTaskId);
          return mjTaskId;
        }
      }
      
      // 从图片URL中提取任务ID (扩展检查)
      const urlTaskIdMatch = this.data.result.match(/drawing_([a-z0-9-]+)/i);
      if (urlTaskIdMatch && urlTaskIdMatch[1]) {
        console.log('从图片URL中提取到系统任务ID:', urlTaskIdMatch[1]);
        console.warn('警告：这不是MJ任务ID，是系统任务ID，可能导致API调用失败');
        // 不再直接返回系统任务ID，继续查找更好的MJ任务ID
      }
    }
    
    // 从所有possibleImageUrls中提取
    if (this.data.possibleImageUrls && this.data.possibleImageUrls.length > 0) {
      // 先检查Discord URL
      for (const url of this.data.possibleImageUrls) {
        if (url && url.includes('cdn.discordapp.com')) {
          const numericMatch = url.match(/\/(\d{15,25})\//);
          if (numericMatch && numericMatch[1]) {
            console.log('从Discord备选URL中提取到可能的MJ任务ID:', numericMatch[1]);
            return numericMatch[1];
          }
        }
      }
      
      // 再检查Midjourney URL
      for (const url of this.data.possibleImageUrls) {
        if (url && url.includes('midjourney.com')) {
          const mjTaskId = this.extractTaskIdFromUrl(url);
          if (mjTaskId) {
            console.log('从Midjourney备选URL中提取到任务ID:', mjTaskId);
            return mjTaskId;
          }
        }
      }
    }
    
    // 从URL参数中尝试提取任务ID
    try {
      const currentURL = this.data.result || '';
      const urlParams = new URLSearchParams(currentURL.split('?')[1] || '');
      const taskIdFromParams = urlParams.get('taskId');
      if (taskIdFromParams && /^\d{15,25}$/.test(taskIdFromParams)) {
        console.log('从URL参数中提取到合法格式的MJ任务ID:', taskIdFromParams);
        return taskIdFromParams;
      }
    } catch (e) {
      console.error('解析URL参数失败:', e);
    }
    
    // 实在找不到有效的MJ任务ID，可以尝试使用系统任务ID，但加警告
    if (this.data.taskId) {
      if (this.data.taskId.startsWith('drawing_')) {
        const strippedId = this.data.taskId.substring(8);
        console.warn('未找到合法的MJ任务ID，使用去前缀的系统任务ID作为后备方案:', strippedId);
        return strippedId;
      } else {
        console.warn('未找到合法的MJ任务ID，使用原始系统任务ID作为后备方案:', this.data.taskId);
        return this.data.taskId;
      }
    }
    
    // MJ任务ID测试值 - 仅供测试使用
    // 警告：这是一个假的测试ID，实际环境应该注释或删除它
    if (app.globalData.debugMode) {
      console.warn('⚠️ 使用测试用MJ任务ID！这仅供调试用，不应在生产环境使用');
      return '1743911725132936';
    }
    
    // 未找到任何有效的任务ID
    console.error('未能从任何来源提取到有效的MJ任务ID');
    return null;
  },
  
  // 保存图片到相册
  saveImage: function() {
    if (!this.data.originalImage) {
      tt.showToast({
        title: '没有可保存的图片',
        icon: 'none'
      });
      return;
    }
    
    // 直接尝试保存，让系统处理权限申请
    tt.showLoading({
      title: '保存中...'
    });
    
    // 先下载图片
    tt.downloadFile({
      url: this.data.originalImage,
      success: (res) => {
        if (res.statusCode === 200) {
          // 保存到相册
          tt.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              tt.hideLoading();
              tt.showToast({
                title: '保存成功',
                icon: 'success'
              });
            },
            fail: (err) => {
              console.error('保存图片失败:', err);
              tt.hideLoading();
              
              // 处理权限错误
              if (err.errMsg && (
                  err.errMsg.includes('auth deny') || 
                  err.errMsg.includes('authorize:fail') ||
                  err.errMsg.includes('not declared in the privacy agreement'))) {
                tt.showModal({
                  title: '保存失败',
                  content: '需要授权保存图片到相册的权限，是否前往设置？',
                  confirmText: '去设置',
                  cancelText: '取消',
                  success: (res) => {
                    if (res.confirm) {
                      // 打开设置页
                      tt.openSetting();
                    }
                  }
                });
              } else {
                // 其他错误
                tt.showToast({
                  title: '保存失败: ' + (err.errMsg || '未知错误'),
                  icon: 'none'
                });
              }
            }
          });
        } else {
          tt.hideLoading();
          tt.showToast({
            title: '图片下载失败: ' + res.statusCode,
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('下载图片失败:', err);
        tt.hideLoading();
        
        // 判断是否网络错误
        if (err.errMsg && err.errMsg.indexOf('timeout') !== -1) {
          tt.showToast({
            title: '下载超时，请检查网络',
            icon: 'none'
          });
        } else {
          tt.showToast({
            title: '下载失败',
            icon: 'none'
          });
        }
      }
    });
  },
  
  // 处理放大按钮点击 (U1-U4)
  handleUpscale: function(e) {
    // 检查冷却时间
    if (!this.checkCooldown()) {
      return;
    }
  
    // 获取点击的是哪个子图（1-4）
    const index = e.currentTarget.dataset.index;
    console.log(`点击了放大按钮 U${index}`);
    
    // 优先使用原始任务ID
    let taskId = this.data.originalMjTaskId;
    
    // 如果没有原始任务ID，尝试从本地存储获取
    if (!taskId) {
      try {
        taskId = tt.getStorageSync('originalMjTaskId');
        if (taskId) {
          console.log('从本地存储获取到原始MJ任务ID:', taskId);
        }
      } catch (e) {
        console.error('读取本地存储的原始MJ任务ID失败:', e);
      }
    }
    
    // 如果仍然没有原始任务ID，尝试使用当前MJ任务ID
    if (!taskId) {
      taskId = this.data.mjTaskId;
      console.log('没有原始MJ任务ID，尝试使用当前MJ任务ID:', taskId);
    }
    
    // 如果仍然没有任务ID，尝试从其他源提取
    if (!taskId) {
      console.log('未找到存储的MJ任务ID，尝试从其他源提取');
      taskId = this.extractMidJourneyTaskIdFromAnySource();
    }
    
    // 确保任务ID可用
    if (!taskId) {
      console.error('未找到有效的任务ID，无法进行放大操作');
      tt.showToast({
        title: '无法获取任务ID',
        icon: 'none'
      });
      return;
    }
    
    // 检查taskId是否是纯数字格式（标准的MJ任务ID格式）
    if (/^\d{15,25}$/.test(taskId)) {
      console.log(`检测到标准MJ格式任务ID: ${taskId}`);
    } else {
      console.warn(`警告：任务ID不是标准MJ格式: ${taskId}，可能导致API调用失败`);
      
      // 如果ID明显是系统UUID格式，提示用户
      if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(taskId) || 
          taskId.startsWith('drawing_')) {
        tt.showModal({
          title: '操作可能失败',
          content: '检测到使用的可能是系统ID而非MJ任务ID，放大操作可能会失败。是否继续？',
          success: (res) => {
            if (res.confirm) {
              // 用户确认继续
              this.proceedWithUpscale(taskId, index);
            }
          }
        });
        return;
      }
    }
    
    // 正常继续放大操作
    this.proceedWithUpscale(taskId, index);
  },
  
  // 执行放大操作的核心逻辑
  proceedWithUpscale: function(taskId, index) {
    console.log(`准备放大图片，使用任务ID: ${taskId}, 索引: ${index}`);
    
    // 显示加载提示
    tt.showLoading({
      title: '正在放大图片...',
      mask: true
    });
    
    // 重置任务完成状态，允许新的查询
    this.setData({
      taskCompleted: false,
      generating: true,
      generationProgress: 5,
      currentOperationType: 'upscale', // 标记当前操作类型为"放大"
      lastGenerationTime: Date.now(), // 记录当前生成时间
      shouldAutoScroll: true // 放大操作完成后需要自动滚动
    });
    
    // 调用API进行放大操作
    api.upscaleImage(taskId, index)
      .then(res => {
        console.log('放大图片请求成功:', res);
        
        if (res.code === 0 && res.data && res.data.taskId) {
          const newTaskId = res.data.taskId;
          console.log(`获取到新的任务ID: ${newTaskId}`);
          
          // 有新的任务ID，开始轮询结果
          if (!this.data.taskCompleted) {
            this.queryDrawingResult(newTaskId);
          } else {
            console.log('任务已完成，不需要开始查询');
            tt.hideLoading();
          }
        } else {
          throw new Error(res.message || '放大图片请求失败');
        }
      })
      .catch(err => {
        console.error('放大图片请求失败:', err);
        
        tt.hideLoading();
        this.setData({
          generating: false,
          taskCompleted: true,
          errorMsg: err.message || '放大图片请求失败，请重试'
        });
        
        tt.showToast({
          title: '放大请求失败',
          icon: 'none'
        });
      });
  },
  
  // 处理变体按钮点击 (V1-V4)
  handleVariation: function(e) {
    // 检查冷却时间
    if (!this.checkCooldown()) {
      return;
    }
    
    // 获取点击的是哪个子图（1-4）
    const index = e.currentTarget.dataset.index;
    console.log(`点击了变体按钮 V${index}`);
    
    // 优先使用原始任务ID
    let taskId = this.data.originalMjTaskId;
    
    // 如果没有原始任务ID，尝试从本地存储获取
    if (!taskId) {
      try {
        taskId = tt.getStorageSync('originalMjTaskId');
        if (taskId) {
          console.log('从本地存储获取到原始MJ任务ID:', taskId);
        }
      } catch (e) {
        console.error('读取本地存储的原始MJ任务ID失败:', e);
      }
    }
    
    // 如果仍然没有原始任务ID，尝试使用当前MJ任务ID
    if (!taskId) {
      taskId = this.data.mjTaskId;
      console.log('没有原始MJ任务ID，尝试使用当前MJ任务ID:', taskId);
    }
    
    // 如果仍然没有任务ID，尝试从其他源提取
    if (!taskId) {
      console.log('未找到存储的MJ任务ID，尝试从其他源提取');
      taskId = this.extractMidJourneyTaskIdFromAnySource();
    }
    
    // 确保任务ID可用
    if (!taskId) {
      console.error('未找到有效的任务ID，无法创建变体');
      tt.showToast({
        title: '无法获取任务ID',
        icon: 'none'
      });
      return;
    }
    
    // 检查taskId是否是纯数字格式（标准的MJ任务ID格式）
    if (/^\d{15,25}$/.test(taskId)) {
      console.log(`检测到标准MJ格式任务ID: ${taskId}`);
    } else {
      console.warn(`警告：任务ID不是标准MJ格式: ${taskId}，可能导致API调用失败`);
      
      // 如果ID明显是系统UUID格式，提示用户
      if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(taskId) || 
          taskId.startsWith('drawing_')) {
        tt.showModal({
          title: '操作可能失败',
          content: '检测到使用的可能是系统ID而非MJ任务ID，变体操作可能会失败。是否继续？',
          success: (res) => {
            if (res.confirm) {
              // 用户确认继续
              this.proceedWithVariation(taskId, index);
            }
          }
        });
        return;
      }
    }
    
    // 正常继续变体操作
    this.proceedWithVariation(taskId, index);
  },
  
  // 执行变体操作的核心逻辑
  proceedWithVariation: function(taskId, index) {
    console.log(`准备创建变体，使用任务ID: ${taskId}, 索引: ${index}`);
    
    // 显示加载提示
    tt.showLoading({
      title: '正在创建变体...',
      mask: true
    });
    
    // 重置任务完成状态，允许新的查询
    this.setData({
      taskCompleted: false,
      generating: true,
      generationProgress: 5,
      currentOperationType: 'variation', // 标记当前操作类型为"变体"
      lastGenerationTime: Date.now(), // 记录当前生成时间
      shouldAutoScroll: true // 变体操作完成后需要自动滚动
    });
    
    // 调用API创建变体
    api.createVariation(taskId, index)
      .then(res => {
        console.log('创建变体请求成功:', res);
        
        if (res.code === 0 && res.data && res.data.taskId) {
          const newTaskId = res.data.taskId;
          console.log(`获取到新的任务ID: ${newTaskId}`);
          
          // 有新的任务ID，开始轮询结果
          if (!this.data.taskCompleted) {
            this.queryDrawingResult(newTaskId);
          } else {
            console.log('任务已完成，不需要开始查询');
            tt.hideLoading();
          }
        } else {
          throw new Error(res.message || '创建变体请求失败');
        }
      })
      .catch(err => {
        console.error('创建变体请求失败:', err);
        
        tt.hideLoading();
        this.setData({
          generating: false,
          taskCompleted: true,
          errorMsg: err.message || '创建变体请求失败，请重试'
        });
        
        tt.showToast({
          title: '变体请求失败',
          icon: 'none'
        });
      });
  },
  
  // 选择模板
  selectTemplate: function(e) {
    const templateId = e.currentTarget.dataset.id;
    const template = this.data.templates.find(t => t.id === templateId);
    
    if (template && template.prompt) {
      this.setData({
        prompt: template.prompt
      });
      
      tt.showToast({
        title: '已应用模板',
        icon: 'none'
      });
    }
  },
  
  // 关闭结果预览
  closeResult: function() {
    this.setData({
      showResult: false
    });
  },
  
  // 处理缩略图点击，显示完整图片
  handleThumbnailClick: function(e) {
    const imageId = e.currentTarget.dataset.id;
    const imageIndex = e.currentTarget.dataset.index;
    const selectedImage = this.data.generatedImages.find(img => img.id === imageId);
    
    if (selectedImage) {
      console.log(`预览图片: ${selectedImage.id}, 类型: ${selectedImage.type}`);
      
      // 提供轻微震动反馈（如果设备支持）
      if (tt.vibrateShort) {
        tt.vibrateShort();
      }
      
      // 使用系统预览功能打开全屏图片预览
      tt.previewImage({
        current: selectedImage.url, // 当前显示图片的URL
        urls: this.data.generatedImages.map(img => img.url), // 所有图片的URL数组
        longPressActions: {
          itemList: ['保存图片', '取消'],
          success: (res) => {
            if (res.tapIndex === 0) { // 选择了保存图片
              this.saveToPhotosAlbum(selectedImage.url);
            }
          },
          fail: (err) => {
            console.log('长按操作失败', err);
          }
        }
      });
      
      // 更新active状态，但不改变主图显示
      this.setData({
        generatedImages: this.data.generatedImages.map((img, idx) => ({
          ...img,
          isActive: idx === imageIndex
        }))
      });
    }
  },
  
  // 新增：保存图片到相册
  saveToPhotosAlbum: function(imageUrl) {
    console.log('准备保存图片到相册:', imageUrl);
    // 显示加载提示
    tt.showLoading({
      title: '保存中...'
    });
    
    // 先下载图片
    tt.downloadFile({
      url: imageUrl,
      success: (res) => {
        if (res.statusCode === 200) {
          // 保存到相册
          tt.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              tt.hideLoading();
              tt.showToast({
                title: '保存成功',
                icon: 'success'
              });
            },
            fail: (err) => {
              console.error('保存图片失败:', err);
              tt.hideLoading();
              
              // 处理权限错误
              if (err.errMsg && (
                  err.errMsg.includes('auth deny') || 
                  err.errMsg.includes('authorize:fail'))) {
                tt.showModal({
                  title: '保存失败',
                  content: '需要授权保存图片到相册的权限，是否前往设置？',
                  confirmText: '去设置',
                  cancelText: '取消',
                  success: (res) => {
                    if (res.confirm) {
                      // 打开设置页
                      tt.openSetting();
                    }
                  }
                });
              } else {
                // 其他错误
                tt.showToast({
                  title: '保存失败',
                  icon: 'none'
                });
              }
            }
          });
        } else {
          tt.hideLoading();
          tt.showToast({
            title: '图片下载失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('下载图片失败:', err);
        tt.hideLoading();
        tt.showToast({
          title: '下载失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 处理长按图片
  handleLongPress: function(e) {
    const imageId = e.currentTarget.dataset.id;
    const selectedImage = this.data.generatedImages.find(img => img.id === imageId);
    
    if (selectedImage) {
      tt.showActionSheet({
        itemList: ['保存图片', '取消'],
        success: (res) => {
          if (res.tapIndex === 0) { // 选择了保存图片
            this.saveToPhotosAlbum(selectedImage.url);
          }
        }
      });
    }
  },
  
  // 处理主图长按
  handleMainImageLongPress: function() {
    console.log('长按主图，准备保存图片:', this.data.originalImage);
    
    if (this.data.originalImage) {
      tt.showActionSheet({
        itemList: ['保存图片到相册', '取消'],
        success: (res) => {
          if (res.tapIndex === 0) { // 选择了保存图片
            this.saveToPhotosAlbum(this.data.originalImage);
          }
        }
      });
    }
  },
  
  // 新增：重置图片生成状态
  resetImageGeneration: function() {
    this.setData({
      result: '',
      originalImage: '',
      generatedImages: [],
      showThumbnails: false
    });
  },
  
  // 添加自动滚动到特定区域的函数
  scrollToView: function(viewId) {
    console.log(`准备滚动到视图区域: ${viewId}`);
    
    try {
      tt.createSelectorQuery()
        .select(viewId)
        .boundingClientRect(rect => {
          if (rect) {
            console.log(`找到元素: ${viewId}，位置信息:`, rect);
            // 滚动到元素位置，给顶部一些偏移量
            tt.pageScrollTo({
              scrollTop: rect.top - 50,
              duration: 300
            });
            console.log(`执行滚动到 ${viewId}`);
          } else {
            console.warn(`未找到元素: ${viewId}`);
          }
        })
        .exec();
    } catch (err) {
      console.error(`滚动到 ${viewId} 时发生错误:`, err);
    }
  },
  
  // 切换页签
  switchTab: function(e) {
    const tab = e.currentTarget.dataset.tab;
    console.log('切换到页签:', tab);
    console.log('当前shouldAutoScroll状态:', this.data.shouldAutoScroll);
    
    // 切换页签时总是禁用自动滚动
    this.setData({
      activeTab: tab,
      inputVisible: tab === 'image', // 只在生图页签显示输入区
      shouldAutoScroll: false // 确保切换页签时禁用自动滚动
    });
    
    console.log('切换页签后shouldAutoScroll已设为:', false);
    
    // 如果切换到AI生图页签，刷新积分信息
    if (tab === 'image') {
      this.refreshCreditsInfo();
      console.log('切换到AI生图页签，不执行自动滚动');
    }
    
    // 当切换到AI视频页签时，不再自动滚动
    if (tab === 'video') {
      console.log('切换到AI视频页签，不执行自动滚动');
      // 只隐藏底部输入框，不添加滚动代码
    }
  },
  
  // 跳转到首页/应用首页
  navigateToHome: function() {
    // 如果已经在首页，刷新内容
    if (this.data.activeTab === 'image') {
      this.refreshContent();
    } else {
      this.switchTab({ currentTarget: { dataset: { tab: 'image' } } });
    }
    
    wx.showToast({
      title: '奇思妙绘',
      icon: 'none',
      duration: 1000
    });
  },
  
  // 显示反馈界面
  showFeedback: function() {
    wx.showToast({
      title: '反馈功能即将上线',
      icon: 'none',
      duration: 2000
    });
  },
  
  // 刷新内容（在首页时可用）
  refreshContent: function() {
    // 如果有原始图片，清除并回到初始状态
    if (this.data.originalImage) {
      this.setData({
        originalImage: '',
        generatedImages: [],
        showThumbnails: false
      });
    }
    
    // 刷新推荐内容
    this.loadPlatformData();
  },
  
  // 选择图片
  chooseImage: function() {
    // 检查已上传图片数量
    if (this.data.uploadedImages.length >= 8) {
      wx.showToast({
        title: '最多只能上传8张图片',
        icon: 'none'
      });
      return;
    }
    
    // 计算还能上传的图片数量
    const remainCount = 8 - this.data.uploadedImages.length;
    
    // 调用选择图片API
    wx.chooseMedia({
      count: remainCount,
      mediaType: ['image'],
      sourceType: ['album'],
      sizeType: ['compressed'],
      success: (res) => {
        const tempFiles = res.tempFiles;
        const newImages = [];
        
        // 收集所有选择的图片
        tempFiles.forEach(file => {
          newImages.push(file.tempFilePath);
        });
        
        // 更新图片数组
        this.setData({
          uploadedImages: [...this.data.uploadedImages, ...newImages]
        });
      }
    });
  },
  
  // 删除上传的图片
  deleteUploadedImage: function(e) {
    const index = e.currentTarget.dataset.index;
    let images = this.data.uploadedImages;
    
    // 从数组中移除指定索引的图片
    images.splice(index, 1);
    
    // 更新数据
    this.setData({
      uploadedImages: images
    });
  },
  
  // 预览图片
  previewUploadedImage: function(e) {
    const index = e.currentTarget.dataset.index;
    const images = this.data.uploadedImages;
    
    wx.previewImage({
      current: images[index],
      urls: images
    });
  },
  
  // 新增：强制滚动到缩略图区域
  forceScrollToThumbnails: function() {
    console.log('强制滚动到缩略图区域');
    try {
      tt.createSelectorQuery()
        .select('.thumbnails-container')
        .boundingClientRect(rect => {
          if (rect) {
            console.log('找到缩略图区域，位置信息:', rect);
            tt.pageScrollTo({
              scrollTop: rect.top - 50,
              duration: 300
            });
            console.log('已执行滚动到缩略图区域');
          } else {
            console.warn('未找到缩略图区域元素');
          }
        })
        .exec();
    } catch (err) {
      console.error('滚动到缩略图区域时发生错误:', err);
    }
  },

  // 为页面添加滚动监听事件
  onPageScroll: function(e) {
    // 当用户滚动页面时隐藏箭头提示
    if (e.scrollTop > 100 && this.data.showScrollHint) {
      this.setData({
        showScrollHint: false
      });
    }
  },
  
  // 新增: 将图片转换为base64编码
  convertImagesToBase64: function(imagePaths) {
    // 如果没有图片，返回空数组
    if (!imagePaths || imagePaths.length === 0) {
      return Promise.resolve([]);
    }
    
    console.log(`开始转换${imagePaths.length}张图片为base64...`);
    
    // 将每个图片路径转换为Promise，然后Promise.all等待所有转换完成
    const imagePromises = imagePaths.map((path, index) => {
      return new Promise((resolve, reject) => {
        console.log(`开始处理第${index + 1}张图片: ${path}`);
        
        // 使用FileSystemManager读取图片文件
        tt.getFileSystemManager().readFile({
          filePath: path,
          encoding: 'base64',
          success: res => {
            // 图片读取成功，组装完整的Data URL
            const base64Data = `data:image/jpeg;base64,${res.data}`;
            console.log(`第${index + 1}张图片转换成功，数据长度: ${base64Data.length}`);
            resolve(base64Data);
          },
          fail: err => {
            // 图片读取失败
            console.error(`第${index + 1}张图片转换失败:`, err);
            reject(err);
          }
        });
      });
    });
    
    // 使用Promise.all等待所有图片转换完成
    return Promise.all(imagePromises)
      .then(base64Images => {
        console.log(`所有图片转换完成，共${base64Images.length}张`);
        return base64Images;
      })
      .catch(err => {
        console.error('图片转换过程中发生错误:', err);
        // 返回空数组，确保后续流程可以继续
        return [];
      });
  },
  
  // 处理图片权重滑动条变化
  onImageWeightChange: function(e) {
    const value = parseFloat(e.detail.value).toFixed(1); // 保留一位小数
    this.setData({
      imageWeight: parseFloat(value) // 转换回数字
    });
    console.log(`图片权重已设置为: ${this.data.imageWeight}`);
  },
}); 